package org.lkp.reggie.controller;

import java.util.*;

public class Main {

    // 定义静态变量来保存棋盘的大小、北边和西边的箭靶数、访问标记以及路径
    static int N;  // 棋盘的大小
    static int[] north, west;  // 分别表示北边和西边的箭靶数
    static boolean[][] visited;  // 标记每个方格是否被访问过
    static List<Integer> path = new ArrayList<>();  // 用来记录骑士的行走路径

    // 定义方向数组，分别对应向下和向右的移动
    static int[] dx = {1, 0};  // 向下的方向是 x 增加 1
    static int[] dy = {0, 1};  // 向右的方向是 y 增加 1

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 读取输入数据
        N = sc.nextInt();  // 棋盘的大小 N×N
        north = new int[N];  // 创建一个长度为 N 的数组，用来保存北边箭靶的数字
        west = new int[N];  // 创建一个长度为 N 的数组，用来保存西边箭靶的数字

        // 读取北边的箭靶数
        for (int i = 0; i < N; i++) {
            north[i] = sc.nextInt();  // 填充 north 数组
        }

        // 读取西边的箭靶数
        for (int i = 0; i < N; i++) {
            west[i] = sc.nextInt();  // 填充 west 数组
        }

        // 创建一个 N×N 的二维数组，用来记录方格是否被访问过
        visited = new boolean[N][N];

        path.clear();  // 清空路径记录
        dfs(0, 0);  // 从起点 (0, 0) 开始进行 DFS 搜索

        // 输出最终路径
        for (int i = 0; i < path.size(); i++) {
            System.out.print(path.get(i));  // 输出路径中的每个方格编号
            if (i != path.size() - 1) {
                System.out.print(" ");  // 每个数字后面加空格，除了最后一个
            }
        }
    }

    // 深度优先搜索 (DFS) 函数，x, y 是当前的坐标
    static void dfs(int x, int y) {
        // 当到达终点 (N-1, N-1) 时，说明找到了一条合法路径
        if (x == N - 1 && y == N - 1) {
            path.add(x * N + y);  // 将当前方格的编号加入路径
            return;  // 结束搜索
        }

        visited[x][y] = true;  // 标记当前方格为已访问
        path.add(x * N + y);  // 将当前方格的编号加入路径

        // 执行移动，尝试向下或向右走
        for (int i = 0; i < 2; i++) {
            int nx = x + dx[i];  // 计算新的 x 坐标
            int ny = y + dy[i];  // 计算新的 y 坐标

            // 检查新的坐标是否在棋盘范围内且该格子未被访问
            if (nx < N && ny < N && !visited[nx][ny]) {
                // 确保当前位置的北边和西边箭靶数符合条件
                if (north[ny] > 0 && west[nx] > 0) {
                    // 如果符合条件，减少相应的箭靶数
                    north[ny]--;  // 向北的箭靶减一
                    west[nx]--;   // 向西的箭靶减一

                    // 递归调用 DFS 来走下一步
                    dfs(nx, ny);

                    // 如果已经找到路径，结束递归
                    if (path.size() == N * N) {
                        return;
                    }

                    // 如果当前路径不可行，回溯，恢复箭靶数
                    north[ny]++;
                    west[nx]++;
                }
            }
        }

        visited[x][y] = false;  // 回溯时标记当前方格为未访问
        path.remove(path.size() - 1);  // 删除当前方格路径，进行回溯
    }
}
